home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 November / EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso / earcd / ear / mui23dev.lha / MUI / Developer / Oberon / txt / MuiSimpleV39.mod < prev    next >
Text File  |  1994-12-21  |  37KB  |  900 lines
  1. (*------------------------------------------
  2.  
  3.   :Module.      MuiSimple.mod
  4.   :Author.      Albert Weinert  [awn]
  5.   :Address.     Adamsstr. 83 , 51063 Köln, Germany
  6.   :EMail.       a.weinert@darkness.gun.de
  7.   :Phone.       +49-221-613100
  8.   :Revision.    R.3
  9.   :Date.        26-Sep-1994
  10.   :Copyright.   Albert Weinert
  11.   :Language.    Oberon-2
  12.   :Translator.  AmigaOberon V3.20
  13.   :Contents.    Contains the object creation on a simple manner (but not so easy)
  14.   :Contents.    This Module is for "GenCodeOberon" which comes with MuiBuilder 2.0.
  15.   :Remarks.     *Don't mix MuiBasics.mod and MuiSimple.mod objects!!* Do that
  16.   :Remarks.     only if you want do dynamic object creation.
  17.   :Bugs.        <Bekannte Fehler>
  18.   :Usage.       <Angaben zur Anwendung>
  19.   :History.     .1     [awn] 02-Jul-1994 : Erstellt
  20.   :History.     .2     [awn] 19-Aug-1994 : Do some work at the Module,
  21.   :History.     .3     [awn] 26-Sep-1994 : Requires now muimaster.library V8
  22.   :History.            Must changed some object creation to work with MakeObject()
  23.   :History.            because MuiBuilder 2.0 use features oft his.
  24.  
  25. --------------------------------------------*)
  26. MODULE MuiSimple;
  27.  
  28. IMPORT e * := Exec,
  29.        I * := Intuition,
  30.        m * := Mui,
  31.        u * := Utility,
  32.        y   :=SYSTEM;
  33.  
  34. TYPE
  35.   Args      * = UNTRACED POINTER TO ArgsDesc;
  36.   ArgsDesc  * = STRUCT END;
  37.  
  38.   HookDef * = PROCEDURE ( hook : u.HookPtr; object : m.Object; args : Args ):LONGINT;
  39.  
  40.   PROCEDURE MakeHook* ( VAR hook : u.Hook; entry: HookDef );
  41.     BEGIN
  42.       u.InitHook( y.ADR( hook ), y.VAL( u.HookFunc, entry ) );
  43.     END MakeHook;
  44.  
  45. (***************************************************************************
  46. ** Class Tree
  47. ****************************************************************************
  48. **
  49. ** rootclass               (BOOPSI's base class)
  50. ** +--Notify               (implements notification mechanism)
  51. **    +--Family            (handles multiple children)
  52. **    !  +--Menustrip      (describes a complete menu strip)
  53. **    !  +--Menu           (describes a single menu)
  54. **    !  \--Menuitem       (describes a single menu item)
  55. **    +--Application       (main class for all applications)
  56. **    +--Window            (handles intuition window related topics)
  57. **    +--Area              (base class for all GUI elements)
  58. **       +--Rectangle      (creates (empty) rectangles)
  59. **       +--Image          (creates images)
  60. **       +--Text           (creates some text)
  61. **       +--String         (creates a string gadget)
  62. **       +--Prop           (creates a proportional gadget)
  63. **       +--Gauge          (creates a fule gauge)
  64. **       +--Scale          (creates a percentage scale)
  65. **       +--Boopsi         (interface to BOOPSI gadgets)
  66. **       +--Colorfield     (creates a field with changeable color)
  67. **       +--List           (creates a line-oriented list)
  68. **       !  +--Floattext   (special list with floating text)
  69. **       !  +--Volumelist  (special list with volumes)
  70. **       !  +--Scrmodelist (special list with screen modes)
  71. **       !  \--Dirlist     (special list with files)
  72. **       +--Group          (groups other GUI elements)
  73. **          +--Register    (handles page groups with titles)
  74. **          +--Virtgroup   (handles virtual groups)
  75. **          +--Scrollgroup (handles virtual groups with scrollers)
  76. **          +--Scrollbar   (creates a scrollbar)
  77. **          +--Listview    (creates a listview)
  78. **          +--Radio       (creates radio buttons)
  79. **          +--Cycle       (creates cycle gadgets)
  80. **          +--Slider      (creates slider gadgets)
  81. **          +--Coloradjust (creates some RGB sliders)
  82. **          +--Palette     (creates a complete palette gadget)
  83. **          +--Colorpanel  (creates a panel of colors)
  84. **          +--Popstring   (base class for popups)
  85. **             +--Popobject(popup a MUI object in a window)
  86. **             \--Popasl   (popup an asl requester)
  87. **
  88. **************************************************************)
  89.   PROCEDURE FamilyObject*{"MuiSimple.FamilyObjectA"} ( tags{9}.. : u.Tag):m.Object;
  90.   PROCEDURE FamilyObjectA*( tags{9} : u.TagListPtr ):m.Object;
  91.     BEGIN (* SaveReg+ *)
  92.       RETURN m.NewObject( m.cFamily, u.more, tags );
  93.     END FamilyObjectA;
  94.  
  95.   PROCEDURE MenustripObject*{"MuiSimple.MenustripObjectA"} ( tags{9}.. : u.Tag):m.Object;
  96.   PROCEDURE MenustripObjectA*( tags{9} : u.TagListPtr ):m.Object;
  97.     BEGIN (* SaveReg+ *)
  98.       RETURN m.NewObject( m.cMenustrip, u.more, tags );
  99.     END MenustripObjectA;
  100.  
  101.   PROCEDURE MenuObject*{"MuiSimple.MenuObjectA"} ( tags{9}.. : u.Tag):m.Object;
  102.   PROCEDURE MenuObjectA*( tags{9} : u.TagListPtr ):m.Object;
  103.     BEGIN (* SaveReg+ *)
  104.       RETURN m.NewObject( m.cMenu, u.more, tags );
  105.     END MenuObjectA;
  106.  
  107.   PROCEDURE MenuTObject*{"MuiSimple.MenuTObjectA"} ( name {8}: ARRAY OF CHAR; tags{9}.. : u.Tag):m.Object;
  108.   PROCEDURE MenuTObjectA*( name {8}: e.STRPTR; tags{9} : u.TagListPtr ):m.Object;
  109.     BEGIN (* SaveReg+ *)
  110.       RETURN m.NewObject( m.cMenu, m.aMenuTitle, name, u.more, tags );
  111.     END MenuTObjectA;
  112.  
  113.   PROCEDURE MenuitemObject*{"MuiSimple.MenuitemObjectA"} ( tags{9}.. : u.Tag):m.Object;
  114.   PROCEDURE MenuitemObjectA*( tags{9} : u.TagListPtr ):m.Object;
  115.     BEGIN (* SaveReg+ *)
  116.       RETURN m.NewObject( m.cMenuitem, u.more, tags );
  117.     END MenuitemObjectA;
  118.  
  119.   PROCEDURE WindowObject*{"MuiSimple.WindowObjectA"} ( tags{9}.. : u.Tag):m.Object;
  120.   PROCEDURE WindowObjectA*( tags{9} : u.TagListPtr ):m.Object;
  121.     BEGIN (* SaveReg+ *)
  122.       RETURN m.NewObject( m.cWindow, u.more, tags );
  123.     END WindowObjectA;
  124.  
  125.   PROCEDURE ImageObject*{"MuiSimple.ImageObjectA"} ( tags{9}.. : u.Tag): m.Object;
  126.   PROCEDURE ImageObjectA*( tags{9} : u.TagListPtr ): m.Object;
  127.     BEGIN (* SaveReg+ *)
  128.       RETURN m.NewObject( m.cImage, u.more, tags );
  129.     END ImageObjectA;
  130.  
  131.   PROCEDURE BitmapObject*{"MuiSimple.BitmapObjectA"} ( tags{9}.. : u.Tag):m.Object;
  132.   PROCEDURE BitmapObjectA*( tags{9} : u.TagListPtr ):m.Object;
  133.     BEGIN (* SaveReg+ *)
  134.       RETURN m.NewObject( m.cBitmap, u.more, tags );
  135.     END BitmapObjectA;
  136.  
  137.   PROCEDURE BodychunkObject*{"MuiSimple.BodychunkObjectA"} ( tags{9}.. : u.Tag):m.Object;
  138.   PROCEDURE BodychunkObjectA*( tags{9} : u.TagListPtr ):m.Object;
  139.     BEGIN (* SaveReg+ *)
  140.       RETURN m.NewObject( m.cBodychunk, u.more, tags );
  141.     END BodychunkObjectA;
  142.  
  143.   PROCEDURE NotifyObject*{"MuiSimple.NotifyObjectA"} ( tags{9}.. : u.Tag): m.Object;
  144.   PROCEDURE NotifyObjectA*( tags{9} : u.TagListPtr ): m.Object;
  145.     BEGIN (* SaveReg+ *)
  146.       RETURN m.NewObject( m.cNotify, u.more, tags );
  147.     END NotifyObjectA;
  148.  
  149.   PROCEDURE ApplicationObject*{"MuiSimple.ApplicationObjectA"} ( tags{9}.. : u.Tag): m.Object;
  150.   PROCEDURE ApplicationObjectA*( tags{9} : u.TagListPtr ): m.Object;
  151.     BEGIN (* SaveReg+ *)
  152.       RETURN m.NewObject( m.cApplication, u.more, tags );
  153.     END ApplicationObjectA;
  154.  
  155.   PROCEDURE TextObject*{"MuiSimple.TextObjectA"} ( tags{9}.. : u.Tag): m.Object;
  156.   PROCEDURE TextObjectA*( tags{9} : u.TagListPtr ): m.Object;
  157.     BEGIN (* SaveReg+ *)
  158.       RETURN m.NewObject( m.cText, u.more, tags );
  159.     END TextObjectA;
  160.  
  161.   PROCEDURE RectangleObject*{"MuiSimple.RectangleObjectA"} ( tags{9}.. : u.Tag): m.Object;
  162.   PROCEDURE RectangleObjectA*( tags{9} : u.TagListPtr ): m.Object;
  163.     BEGIN (* SaveReg+ *)
  164.       RETURN m.NewObject( m.cRectangle, u.more, tags );
  165.     END RectangleObjectA;
  166.  
  167.   PROCEDURE ListObject*{"MuiSimple.ListObjectA"} ( tags{9}.. : u.Tag): m.Object;
  168.   PROCEDURE ListObjectA*( tags{9} : u.TagListPtr ): m.Object;
  169.     BEGIN (* SaveReg+ *)
  170.       RETURN m.NewObject( m.cList, u.more, tags );
  171.     END ListObjectA;
  172.  
  173.   PROCEDURE PropObject*{"MuiSimple.PropObjectA"} ( tags{9}.. : u.Tag): m.Object;
  174.   PROCEDURE PropObjectA*( tags{9} : u.TagListPtr ): m.Object;
  175.     BEGIN (* SaveReg+ *)
  176.       RETURN m.NewObject( m.cProp, u.more, tags );
  177.     END PropObjectA;
  178.  
  179.   PROCEDURE StringObject*{"MuiSimple.StringObjectA"} ( tags{9}.. : u.Tag): m.Object;
  180.   PROCEDURE StringObjectA*( tags{9} : u.TagListPtr ): m.Object;
  181.     BEGIN (* SaveReg+ *)
  182.       RETURN m.NewObject( m.cString, u.more, tags );
  183.     END StringObjectA;
  184.  
  185.   PROCEDURE ScrollbarObject*{"MuiSimple.ScrollbarObjectA"} ( tags{9}.. : u.Tag): m.Object;
  186.   PROCEDURE ScrollbarObjectA*( tags{9} : u.TagListPtr ): m.Object;
  187.     BEGIN (* SaveReg+ *)
  188.       RETURN m.NewObject( m.cScrollbar, u.more, tags );
  189.     END ScrollbarObjectA;
  190.  
  191.   PROCEDURE ListviewObject*{"MuiSimple.ListviewObjectA"} ( tags{9}.. : u.Tag): m.Object;
  192.   PROCEDURE ListviewObjectA*( tags{9} : u.TagListPtr ): m.Object;
  193.     BEGIN (* SaveReg+ *)
  194.       RETURN m.NewObject( m.cListview, u.more, tags );
  195.     END ListviewObjectA;
  196.  
  197.   PROCEDURE RadioObject*{"MuiSimple.RadioObjectA"} ( tags{9}.. : u.Tag): m.Object;
  198.   PROCEDURE RadioObjectA*( tags{9} : u.TagListPtr ): m.Object;
  199.     BEGIN (* SaveReg+ *)
  200.       RETURN m.NewObject( m.cRadio, u.more, tags );
  201.     END RadioObjectA;
  202.  
  203.   PROCEDURE VolumelistObject*{"MuiSimple.VolumelistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  204.   PROCEDURE VolumelistObjectA*( tags{9} : u.TagListPtr ): m.Object;
  205.     BEGIN (* SaveReg+ *)
  206.       RETURN m.NewObject( m.cVolumelist, u.more, tags );
  207.     END VolumelistObjectA;
  208.  
  209.   PROCEDURE FloattextObject*{"MuiSimple.FloattextObjectA"} ( tags{9}.. : u.Tag): m.Object;
  210.   PROCEDURE FloattextObjectA*( tags{9} : u.TagListPtr ): m.Object;
  211.     BEGIN (* SaveReg+ *)
  212.       RETURN m.NewObject( m.cFloattext, u.more, tags );
  213.     END FloattextObjectA;
  214.  
  215.   PROCEDURE DirlistObject*{"MuiSimple.DirlistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  216.   PROCEDURE DirlistObjectA*( tags{9} : u.TagListPtr ): m.Object;
  217.     BEGIN (* SaveReg+ *)
  218.       RETURN m.NewObject( m.cDirlist, u.more, tags );
  219.     END DirlistObjectA;
  220.  
  221.   PROCEDURE SliderObject*{"MuiSimple.SliderObjectA"} ( tags{9}.. : u.Tag): m.Object;
  222.   PROCEDURE SliderObjectA*( tags{9} : u.TagListPtr ): m.Object;
  223.     BEGIN (* SaveReg+ *)
  224.       RETURN m.NewObject( m.cSlider, u.more, tags );
  225.     END SliderObjectA;
  226.  
  227.   PROCEDURE CycleObject*{"MuiSimple.CycleObjectA"} ( tags{9}.. : u.Tag): m.Object;
  228.   PROCEDURE CycleObjectA*( tags{9} : u.TagListPtr ): m.Object;
  229.     BEGIN (* SaveReg+ *)
  230.       RETURN m.NewObject( m.cCycle, u.more, tags );
  231.     END CycleObjectA;
  232.  
  233.   PROCEDURE GaugeObject*{"MuiSimple.GaugeObjectA"} ( tags{9}.. : u.Tag): m.Object;
  234.   PROCEDURE GaugeObjectA*( tags{9} : u.TagListPtr ): m.Object;
  235.     BEGIN (* SaveReg+ *)
  236.       RETURN m.NewObject( m.cGauge, u.more, tags );
  237.     END GaugeObjectA;
  238.  
  239.   PROCEDURE ScaleObject*{"MuiSimple.ScaleObjectA"} ( tags{9}.. : u.Tag): m.Object;
  240.   PROCEDURE ScaleObjectA*( tags{9} : u.TagListPtr ): m.Object;
  241.     BEGIN (* SaveReg+ *)
  242.       RETURN m.NewObject( m.cScale, u.more, tags );
  243.     END ScaleObjectA;
  244.  
  245.   PROCEDURE BoopsiObject*{"MuiSimple.BoopsiObjectA"} ( tags{9}.. : u.Tag): m.Object;
  246.   PROCEDURE BoopsiObjectA*( tags{9} : u.TagListPtr ): m.Object;
  247.     BEGIN (* SaveReg+ *)
  248.       RETURN m.NewObject( m.cBoopsi, u.more, tags );
  249.     END BoopsiObjectA;
  250.  
  251.   PROCEDURE ColorfieldObject*{"MuiSimple.ColorfieldObjectA"} ( tags{9}.. : u.Tag): m.Object;
  252.   PROCEDURE ColorfieldObjectA*( tags{9} : u.TagListPtr ): m.Object;
  253.     BEGIN (* SaveReg+ *)
  254.       RETURN m.NewObject( m.cColorfield, u.more, tags );
  255.     END ColorfieldObjectA;
  256.  
  257.   PROCEDURE ColorpanelObject*{"MuiSimple.ColorpanelObjectA"} ( tags{9}.. : u.Tag):m.Object;
  258.   PROCEDURE ColorpanelObjectA*( tags{9} : u.TagListPtr ):m.Object;
  259.     BEGIN (* SaveReg+ *)
  260.       RETURN m.NewObject( m.cColorpanel, u.more, tags );
  261.     END ColorpanelObjectA;
  262.  
  263.   PROCEDURE ColoradjustObject*{"MuiSimple.ColoradjustObjectA"} ( tags{9}.. : u.Tag): m.Object;
  264.   PROCEDURE ColoradjustObjectA*( tags{9} : u.TagListPtr ): m.Object;
  265.     BEGIN (* SaveReg+ *)
  266.       RETURN m.NewObject( m.cColoradjust, u.more, tags );
  267.     END ColoradjustObjectA;
  268.  
  269.  PROCEDURE PaletteObject*{"MuiSimple.PaletteObjectA"} ( tags{9}.. : u.Tag): m.Object;
  270.   PROCEDURE PaletteObjectA*( tags{9} : u.TagListPtr ): m.Object;
  271.     BEGIN (* SaveReg+ *)
  272.       RETURN m.NewObject( m.cPalette, u.more, tags );
  273.     END PaletteObjectA;
  274.  
  275.   PROCEDURE GroupObject*{"MuiSimple.GroupObjectA"} ( tags{9}.. : u.Tag): m.Object;
  276.   PROCEDURE GroupObjectA*( tags{9} : u.TagListPtr ): m.Object;
  277.     BEGIN (* SaveReg+ *)
  278.       RETURN m.NewObject( m.cGroup, u.more, tags );
  279.     END GroupObjectA;
  280.  
  281.   PROCEDURE RegisterObject*{"MuiSimple.RegisterObjectA"} ( tags{9}.. : u.Tag): m.Object;
  282.   PROCEDURE RegisterObjectA*( tags{9} : u.TagListPtr ): m.Object;
  283.     BEGIN (* SaveReg+ *)
  284.       RETURN m.NewObject( m.cRegister, u.more, tags );
  285.     END RegisterObjectA;
  286.  
  287.   PROCEDURE VirtgroupObject*{"MuiSimple.VirtgroupObjectA"} ( tags{9}.. : u.Tag): m.Object;
  288.   PROCEDURE VirtgroupObjectA*( tags{9} : u.TagListPtr ): m.Object;
  289.     BEGIN (* SaveReg+ *)
  290.       RETURN m.NewObject( m.cVirtgroup, u.more, tags );
  291.     END VirtgroupObjectA;
  292.  
  293.   PROCEDURE ScrollgroupObject*{"MuiSimple.ScrollgroupObjectA"} ( tags{9}.. : u.Tag ): m.Object;
  294.   PROCEDURE ScrollgroupObjectA*( tags{9} : u.TagListPtr ): m.Object;
  295.     BEGIN (* SaveReg+ *)
  296.       RETURN m.NewObject( m.cScrollgroup, u.more, tags );
  297.     END ScrollgroupObjectA;
  298.  
  299.   PROCEDURE PopstringObject*{"MuiSimple.PopstringObjectA"} ( tags{9}.. : u.Tag): m.Object;
  300.   PROCEDURE PopstringObjectA*( tags{9} : u.TagListPtr ): m.Object;
  301.     BEGIN (* SaveReg+ *)
  302.       RETURN m.NewObject( m.cPopstring, u.more, tags );
  303.     END PopstringObjectA;
  304.  
  305.   PROCEDURE PopobjectObject*{"MuiSimple.PopobjectObjectA"} ( tags{9}.. : u.Tag): m.Object;
  306.   PROCEDURE PopobjectObjectA*( tags{9} : u.TagListPtr ): m.Object;
  307.     BEGIN (* SaveReg+ *)
  308.       RETURN m.NewObject( m.cPopobject, u.more, tags );
  309.     END PopobjectObjectA;
  310.  
  311.   PROCEDURE PoplistObject*{"MuiSimple.PoplistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  312.   PROCEDURE PoplistObjectA*( tags{9} : u.TagListPtr ): m.Object;
  313.     BEGIN (* SaveReg+ *)
  314.       RETURN m.NewObject( m.cPoplist, u.more, tags );
  315.     END PoplistObjectA;
  316.  
  317.   PROCEDURE PopaslObject*{"MuiSimple.PopaslObjectA"} ( tags{9}.. : u.Tag): m.Object;
  318.   PROCEDURE PopaslObjectA*( tags{9} : u.TagListPtr ): m.Object;
  319.     BEGIN (* SaveReg+ *)
  320.       RETURN m.NewObject( m.cPopasl, u.more, tags );
  321.     END PopaslObjectA;
  322.  
  323.   PROCEDURE ScrmodelistObject*{"MuiSimple.ScrmodelistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  324.   PROCEDURE ScrmodelistObjectA*( tags{9} : u.TagListPtr ): m.Object;
  325.     BEGIN (* SaveReg+ *)
  326.       RETURN m.NewObject( m.cScrmodelist, u.more, tags );
  327.     END ScrmodelistObjectA;
  328.  
  329.   PROCEDURE VGroup*{"MuiSimple.VGroupA"}( tags{9}.. : u.Tag ): m.Object;
  330.   PROCEDURE VGroupA*( tags{9} : u.TagListPtr ): m.Object;
  331.     BEGIN (* SaveReg+ *)
  332.       RETURN m.NewObject( m.cGroup, u.more, tags );
  333.     END VGroupA;
  334.  
  335.   PROCEDURE HGroup*{"MuiSimple.HGroupA"}( tags{9}.. : u.Tag ): m.Object;
  336.   PROCEDURE HGroupA*( tags{9} : u.TagListPtr ): m.Object;
  337.     BEGIN (* SaveReg+ *)
  338.       RETURN m.NewObject( m.cGroup, m.aGroupHoriz, e.true, u.more, tags );
  339.     END HGroupA;
  340.  
  341.   PROCEDURE ColGroup*{"MuiSimple.ColGroupA"} ( cols{3} : LONGINT; tags{9}.. : u.Tag );
  342.   PROCEDURE ColGroupA*( cols{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
  343.     BEGIN (* SaveReg+ *)
  344.       RETURN m.NewObject( m.cGroup, m.aGroupColumns, cols, u.more, tags );
  345.     END ColGroupA;
  346.  
  347.   PROCEDURE RowGroup*{"MuiSimple.RowGroupA"}( rows{3} : LONGINT; tags{9}.. : u.Tag  ): m.Object;
  348.   PROCEDURE RowGroupA*( rows{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
  349.     BEGIN (* SaveReg+ *)
  350.       RETURN m.NewObject( m.cGroup, m.aGroupRows, rows, u.more, tags );
  351.     END RowGroupA;
  352.  
  353.   PROCEDURE PageGroup*{"MuiSimple.PageGroupA"}( tags{9}.. : u.Tag ): m.Object;
  354.   PROCEDURE PageGroupA*( tags{9} : u.TagListPtr ): m.Object;
  355.     BEGIN (* SaveReg+ *)
  356.       RETURN m.NewObject( m.cGroup, m.aGroupPageMode, e.true, u.more, tags );
  357.     END PageGroupA;
  358.  
  359.   PROCEDURE VGroupV*{"MuiSimple.VGroupVA"}( tags{9}.. : u.Tag ): m.Object;
  360.   PROCEDURE VGroupVA*( tags{9} : u.TagListPtr ): m.Object;
  361.     BEGIN (* SaveReg+ *)
  362.       RETURN m.NewObject( m.cVirtgroup, u.more, tags );
  363.     END VGroupVA;
  364.  
  365.   PROCEDURE HGroupV*{"MuiSimple.HGroupVA"}( tags{9}.. : u.Tag ): m.Object;
  366.   PROCEDURE HGroupVA*( tags{9} : u.TagListPtr ): m.Object;
  367.     BEGIN (* SaveReg+ *)
  368.       RETURN m.NewObject( m.cVirtgroup, m.aGroupHoriz, e.true, u.more, tags );
  369.     END HGroupVA;
  370.  
  371.   PROCEDURE ColGroupV*{"MuiSimple.ColGroupVA"} ( cols{3} : LONGINT; tags{9}.. : u.Tag ): m.Object;
  372.   PROCEDURE ColGroupVA*( cols{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
  373.     BEGIN (* SaveReg+ *)
  374.       RETURN m.NewObject( m.cVirtgroup, m.aGroupColumns, cols, u.more, tags );
  375.     END ColGroupVA;
  376.  
  377.   PROCEDURE RowGroupV*{"MuiSimple.RowGroupVA"}( rows{3} : LONGINT; tags{9}.. : u.Tag  ): m.Object;
  378.   PROCEDURE RowGroupVA*( rows{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
  379.     BEGIN (* SaveReg+ *)
  380.       RETURN m.NewObject( m.cVirtgroup, m.aGroupRows, rows, u.more, tags);
  381.     END RowGroupVA;
  382.  
  383.   PROCEDURE PageGroupV*{"MuiSimple.PageGroupVA"}( tags{9}.. : u.Tag ): m.Object;
  384.   PROCEDURE PageGroupVA*( tags{9} : u.TagListPtr ): m.Object;
  385.     BEGIN (* SaveReg+ *)
  386.       RETURN m.NewObject( m.cVirtgroup, m.aGroupPageMode, e.true, u.more, tags );
  387.     END PageGroupVA;
  388.  
  389.   PROCEDURE RegisterGroup*{"MuiSimple.RegisterGroupA"}( t{8} : e.APTR; tags{9}.. : u.Tag ): m.Object;
  390.   PROCEDURE RegisterGroupA*( t{8} : e.APTR; tags{9} : u.TagListPtr ): m.Object;
  391.     BEGIN (* SaveReg+ *)
  392.       RETURN m.NewObject( m.cRegister, m.aRegisterTitles, t, u.more, tags );
  393.     END RegisterGroupA;
  394.  
  395.  
  396. (***************************************************************************
  397. **
  398. ** Baring Procedures
  399. ** ------------------
  400. **
  401. ***************************************************************************)
  402.  
  403.   PROCEDURE HBar*(): m.Object;
  404.     BEGIN (* SaveReg+ *)
  405.       RETURN m.NewObject( m.cRectangle,
  406.                           m.aRectangleHBar, e.true,
  407.                           m.aFixHeight, 2,
  408.                           u.done ) ;
  409.     END HBar;
  410.  
  411.   PROCEDURE VBar*(): m.Object;
  412.     BEGIN (* SaveReg+ *)
  413.       RETURN m.NewObject( m.cRectangle,
  414.                           m.aRectangleVBar, e.true,
  415.                           m.aFixWidth, 2,
  416.                           u.done );
  417.     END VBar;
  418.  
  419. (***************************************************************************
  420. **
  421. ** Spacing Procedures
  422. ** ------------------
  423. **
  424. ***************************************************************************)
  425.  
  426.   PROCEDURE HVSpace*(): m.Object;
  427.     BEGIN (* SaveReg+ *)
  428.       RETURN m.NewObject( m.cRectangle, u.done );
  429.     END HVSpace;
  430.  
  431. (*
  432.  *  PROCEDURE GroupSpacing*( x: LONGINT );
  433.  *  (*  *)
  434.  *    BEGIN (* SaveReg+ *)
  435.  *      TagItem( m.aGroupSpacing, x );
  436.  *    END GroupSpacing;
  437.  *)
  438.  
  439.   PROCEDURE HSpace*( x : LONGINT ): m.Object;
  440.     BEGIN (* SaveReg+ *)
  441.       RETURN m.MakeObject( m.oHSpace, x );
  442.     END HSpace;
  443.  
  444.   PROCEDURE VSpace*( x : LONGINT ): m.Object;
  445.     BEGIN (* SaveReg+ *)
  446.       RETURN m.MakeObject( m.oVSpace, x );
  447.     END VSpace;
  448.  
  449.  
  450.   PROCEDURE HCenterObject*( obj : m.Object ): m.Object;
  451.     VAR spL, spR : m.Object;
  452.     BEGIN (* SaveReg+ *)
  453.       spL := HSpace( 0 );
  454.       spR := HSpace( 0 );
  455.       RETURN HGroup( m.aGroupSpacing, 0,
  456.                      m.aGroupChild, spL,
  457.                      m.aGroupChild, obj,
  458.                      m.aGroupChild, spR,
  459.                      u.end );
  460.     END HCenterObject;
  461.  
  462.   PROCEDURE VCenterObject*( obj : m.Object ): m.Object;
  463.     VAR spO, spU : m.Object;
  464.     BEGIN (* SaveReg+ *)
  465.       spO := VSpace( 0 );
  466.       spU := VSpace( 0 );
  467.       RETURN VGroup( m.aGroupSpacing,0,
  468.                      m.aGroupChild, spO,
  469.                      m.aGroupChild, obj,
  470.                      m.aGroupChild, spU,
  471.                      u.end );
  472.     END VCenterObject;
  473.  
  474.  
  475. (*
  476.  *  PROCEDURE InnerSpacing*( h, v : LONGINT );
  477.  *  (*  *)
  478.  *    BEGIN (* SaveReg+ *)
  479.  *      Tags( m.aInnerLeft   , h,
  480.  *            m.aInnerRight  , h,
  481.  *            m.aInnerTop    , v,
  482.  *            m.aInnerBottom , v,
  483.  *            u.end );
  484.  *    END InnerSpacing;
  485.  *)
  486.  
  487.  
  488. (***************************************************************************
  489. **
  490. ** String-Object
  491. ** -------------
  492. **
  493. ** The following procedure creates a simple string gadget.
  494. **
  495. ***************************************************************************)
  496.  
  497.   PROCEDURE String * {"MuiSimple.StringA"} ( contents{8} : ARRAY OF CHAR; maxlen{3} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  498.   PROCEDURE StringA*( contents{8} : e.STRPTR; maxlen{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  499.     BEGIN (* SaveReg+ *)
  500.       RETURN StringObject( m.aFrame, m.vFrameString,
  501.                            m.aStringMaxLen, maxlen,
  502.                            m.aStringContents, contents,
  503.                            u.more, tags );
  504.     END StringA;
  505.  
  506.   PROCEDURE KeyString * {"MuiSimple.KeyStringA"} ( contents{8} : ARRAY OF CHAR; maxlen{3} : LONGINT; controlchar{4}: CHAR; tags{9}.. : u.Tag ):m.Object;
  507.   PROCEDURE KeyStringA*( contents{8} : e.STRPTR; maxlen{3} : LONGINT; controlchar{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  508.     BEGIN (* SaveReg+ *)
  509.       RETURN String( contents^, maxlen, m.aControlChar, controlchar, u.more, tags );
  510.     END KeyStringA;
  511.  
  512. (***************************************************************************
  513. **
  514. ** Integer-Object
  515. ** --------------
  516. **
  517. ** The following procedure creates a simple integer string gadget.
  518. **
  519. ***************************************************************************)
  520.  
  521.   PROCEDURE Integer * {"MuiSimple.IntegerA"} ( contents{0} : LONGINT; maxlen{1} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  522.   PROCEDURE IntegerA*( contents{0} : LONGINT; maxlen{1} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  523.     BEGIN (* SaveReg+ *)
  524.       RETURN StringObject( m.aFrame, m.vFrameString,
  525.                            m.aStringMaxLen, maxlen,
  526.                            m.aStringInteger, contents,
  527.                            m.aStringAccept, y.ADR( "0123456789" ),
  528.                            u.more, tags );
  529.     END IntegerA;
  530.  
  531.   PROCEDURE KeyInteger * {"MuiSimple.KeyIntegerA"} ( contents{0} : LONGINT; maxlen{1} : LONGINT; controlchar{2}: CHAR; tags{9}.. : u.Tag ):m.Object;
  532.   PROCEDURE KeyIntegerA*( contents{0} : LONGINT; maxlen{1} : LONGINT; controlchar{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  533.     BEGIN (* SaveReg+ *)
  534.       RETURN Integer( contents, maxlen, m.aControlChar, controlchar, u.more, tags );
  535.     END KeyIntegerA;
  536.  
  537. (***************************************************************************
  538. **
  539. ** CheckMark-Object
  540. ** ----------------
  541. **
  542. ** The following procedure creates a checkmark gadget.
  543. **
  544. ***************************************************************************)
  545.  
  546.   PROCEDURE CheckMark * {"MuiSimple.CheckMarkA"}( checked{4} : BOOLEAN; tags{9}.. : u.Tag ):m.Object;
  547.   PROCEDURE CheckMarkA*( checked{4} : e.LONGBOOL; tags{9} : u.TagListPtr ):m.Object;
  548.    BEGIN (* SaveReg+ *)
  549.     RETURN ImageObject( m.aFrame, m.vFrameImageButton,
  550.                         m.aInputMode, m.vInputModeToggle,
  551.                         m.aImageSpec, m.iCheckMark,
  552.                         m.aImageFreeVert, e.true,
  553.                         m.aSelected, checked,
  554.                         m.aBackground, m.iButtonBack,
  555.                         m.aShowSelState, e.false,
  556.                         u.more, tags );
  557.     END CheckMarkA;
  558.  
  559.   PROCEDURE KeyCheckMark *{"MuiSimple.KeyCheckMarkA"}( checked{4} : BOOLEAN; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  560.   PROCEDURE KeyCheckMarkA*( checked{4} : e.LONGBOOL; key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  561.    BEGIN (* SaveReg+ *)
  562.     RETURN CheckMark( y.VAL(BOOLEAN,SHORT(SHORT(checked))), m.aControlChar, key, u.more, tags );
  563.     END KeyCheckMarkA;
  564.  
  565.  
  566. (***************************************************************************
  567. **
  568. ** Button-Objects
  569. ** --------------
  570. **
  571. ** Note: Use small letters for KeyButtons, e.g.
  572. **       KeyButton("Cancel",'c')  and not  KeyButton("Cancel",'C') !!
  573. **
  574. ***************************************************************************)
  575.  
  576.   PROCEDURE Button* {"MuiSimple.ButtonA"} ( label{8} : ARRAY OF CHAR ): m.Object;
  577.   PROCEDURE ButtonA* (label{8} : y.ADDRESS ):m.Object;
  578.     BEGIN
  579.       RETURN m.MakeObject( m.oButton, label );
  580.     END ButtonA;
  581.             
  582.   PROCEDURE SimpleButton * {"MuiSimple.SimpleButtonA"} ( name{8} : ARRAY OF CHAR ):m.Object;
  583.   PROCEDURE SimpleButtonA * ( name{8} : e.STRPTR ):m.Object;
  584.     BEGIN (* SaveReg+ *)
  585.       RETURN m.MakeObject( m.oButton, name );
  586.     END SimpleButtonA;
  587.  
  588.  
  589. (***************************************************************************
  590. **
  591. ** Cycle-Object
  592. ** ------------
  593. **
  594. ***************************************************************************)
  595.  
  596.   PROCEDURE Cycle * {"MuiSimple.CycleA"} ( entries{10} : e.APTR; tags{9}.. : u.Tag ):m.Object;
  597.   PROCEDURE CycleA * ( entries{10} : e.APTR; tags{9} : u.TagListPtr ):m.Object;
  598.     BEGIN (* SaveReg+ *)
  599.       RETURN CycleObject( m.aCycleEntries, entries, u.more, tags );
  600.     END CycleA;
  601.  
  602.   PROCEDURE KeyCycle * {"MuiSimple.KeyCycleA"} ( entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag ):m.Object;
  603.   PROCEDURE KeyCycleA * ( entries{10} : e.APTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  604.     BEGIN (* SaveReg+ *)
  605.       RETURN Cycle( entries, m.aControlChar, key, u.more, tags );
  606.     END KeyCycleA;
  607.  
  608. (***************************************************************************
  609. **
  610. ** Radio-Object
  611. ** ------------
  612. **
  613. ***************************************************************************)
  614.  
  615.   PROCEDURE Radio * {"MuiSimple.RadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; tags{9}.. : u.Tag ):m.Object;
  616.   PROCEDURE RadioA * ( name{8}: e.STRPTR; entries{10} : e.APTR; tags{9} : u.TagListPtr ):m.Object;
  617.     BEGIN (* SaveReg+ *)
  618.       RETURN RadioObject( m.aFrame, m.vFrameGroup,
  619.                           m.aFrameTitle, name,
  620.                           m.aRadioEntries, entries,
  621.                           u.more, tags );
  622.     END RadioA;
  623.  
  624.   PROCEDURE KeyRadio * {"MuiSimple.KeyRadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag ):m.Object;
  625.   PROCEDURE KeyRadioA * ( name{8}: e.STRPTR; entries{10} : e.APTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  626.     BEGIN (* SaveReg+ *)
  627.       RETURN Radio( name^, entries, m.aControlChar, key, u.more, tags );
  628.     END KeyRadioA;
  629.  
  630. (***************************************************************************
  631. **
  632. ** Slider-Object
  633. ** -------------
  634. **
  635. ***************************************************************************)
  636.  
  637.   PROCEDURE Slider * {"MuiSimple.SliderA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  638.   PROCEDURE SliderA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  639.     BEGIN (* SaveReg+ *)
  640.       RETURN SliderObject( m.aSliderMin, min,
  641.                            m.aSliderMax, max,
  642.                            m.aSliderLevel, level,
  643.                            u.more, tags );
  644.     END SliderA;
  645.  
  646.   PROCEDURE KeySlider * {"MuiSimple.KeySliderA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  647.   PROCEDURE KeySliderA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  648.     BEGIN (* SaveReg+ *)
  649.       RETURN Slider( min, max, level, m.aControlChar, key, u.more, tags );
  650.     END KeySliderA;
  651.  
  652.   PROCEDURE VSlider * {"MuiSimple.VSliderA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  653.   PROCEDURE VSliderA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  654.     BEGIN (* SaveReg+ *)
  655.       RETURN Slider( min, max, level, m.aGroupHoriz, e.false, u.more, tags );
  656.     END VSliderA;
  657.  
  658.   PROCEDURE KeyVSlider * {"MuiSimple.KeyVSliderA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  659.   PROCEDURE KeyVSliderA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  660.     BEGIN (* SaveReg+ *)
  661.       RETURN VSlider( min,  max, level, m.aControlChar, key, u.more, tags );
  662.     END KeyVSliderA;
  663.  
  664. (***************************************************************************
  665. **
  666. ** Scrollbar-Object
  667. ** -------------
  668. **
  669. ***************************************************************************)
  670.  
  671.   PROCEDURE Scrollbar * {"MuiSimple.ScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  672.   PROCEDURE ScrollbarA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  673.     BEGIN (* SaveReg+ *)
  674.       RETURN ScrollbarObject( m.aSliderMin, min,
  675.                               m.aSliderMax, max,
  676.                               m.aSliderLevel, level,
  677.                               m.aGroupHoriz, e.true,
  678.                               u.more, tags );
  679.     END ScrollbarA;
  680.  
  681.   PROCEDURE KeyScrollbar * {"MuiSimple.KeyScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  682.   PROCEDURE KeyScrollbarA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  683.     BEGIN (* SaveReg+ *)
  684.       RETURN Scrollbar( min, max, level, m.aControlChar, key, u.more, tags );
  685.     END KeyScrollbarA;
  686.  
  687.   PROCEDURE VScrollbar * {"MuiSimple.VScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  688.   PROCEDURE VScrollbarA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  689.     BEGIN (* SaveReg+ *)
  690.       RETURN ScrollbarObject( m.aSliderMin, min,
  691.                               m.aSliderMax, max,
  692.                               m.aSliderLevel, level,
  693.                               u.more, tags );
  694.     END VScrollbarA;
  695.  
  696.   PROCEDURE KeyVScrollbar * {"MuiSimple.KeyVScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  697.   PROCEDURE KeyVScrollbarA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  698.     BEGIN (* SaveReg+ *)
  699.       RETURN VScrollbar( min, max, level, m.aControlChar, key, u.more, tags );
  700.     END KeyVScrollbarA;
  701.  
  702. (***************************************************************************
  703. **
  704. ** Button to be used for popup objects
  705. **
  706. ***************************************************************************)
  707.  
  708.   PROCEDURE PopButton* {"MuiSimple.PopButtonA"} ( img{3} : LONGINT ):m.Object;
  709.   PROCEDURE PopButtonA*( img{3} : LONGINT ):m.Object;
  710.     BEGIN (* SaveReg+ *)
  711.       RETURN m.MakeObject( m.oPopButton, img );
  712.     END PopButtonA;
  713.  
  714. (***************************************************************************
  715. **
  716. ** Labeling Objects
  717. ** ----------------
  718. **
  719. ** Labeling objects, e.g. a group of string gadgets,
  720. **
  721. **   Small: |foo   |
  722. **  Normal: |bar   |
  723. **     Big: |foobar|
  724. **    Huge: |barfoo|
  725. **
  726. ** is done using a 2 column group:
  727. **
  728. ** ColGroup(2);
  729. **      Child; Label2( "Small:"  );
  730. **    Child; StringObject; end;
  731. **      Child; Label2( "Normal:" );
  732. **    Child; StringObject; end;
  733. **      Child; Label2( "Big:"    );
  734. **    Child; StringObject; end;
  735. **      Child; Label2( "Huge:"   );
  736. **    Child; StringObject; end;
  737. **    end;
  738. **
  739. ** Note that we have three versions of the label procedure, depending on
  740. ** the frame type of the right hand object:
  741. **
  742. ** Label1(): For use with standard frames (e.g. checkmarks).
  743. ** Label2(): For use with double high frames (e.g. string gadgets).
  744. ** Label() : For use with objects without a frame.
  745. **
  746. ** These procedures ensure that your label will look fine even if the
  747. ** user of your application configured some strange spacing values.
  748. ** If you want to use your own labeling, you'll have to pay attention
  749. ** on this topic yourself.
  750. **
  751. ***************************************************************************)
  752.  
  753.   PROCEDURE LLabel* {"MuiSimple.LLabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  754.   PROCEDURE LLabelA * ( label{8} : e.STRPTR ):m.Object;
  755.     BEGIN (* SaveReg+ *)
  756.       RETURN m.MakeObject( m.oLabel, label, m.oLabelLeftAligned );
  757.     END LLabelA;
  758.  
  759.   PROCEDURE LLabel1* {"MuiSimple.LLabel1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  760.   PROCEDURE LLabel1A * ( label{8} : e.STRPTR ):m.Object;
  761.     BEGIN (* SaveReg+ *)
  762.       RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame+m.oLabelLeftAligned );
  763.     END LLabel1A;
  764.  
  765.   PROCEDURE LLabel2* {"MuiSimple.LLabel2A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  766.   PROCEDURE LLabel2A * ( label{8} : e.STRPTR ):m.Object;
  767.     BEGIN (* SaveReg+ *)
  768.       RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame+m.oLabelLeftAligned );
  769.     END LLabel2A;
  770.  
  771.   PROCEDURE Label* {"MuiSimple.LabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  772.   PROCEDURE LabelA * ( label{8} : e.STRPTR ):m.Object;
  773.     BEGIN (* SaveReg+ *)
  774.       RETURN m.MakeObject( m.oLabel, label, 0 );
  775.     END LabelA;
  776.  
  777.   PROCEDURE Label1* {"MuiSimple.Label1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  778.   PROCEDURE Label1A * ( label{8} : e.STRPTR ):m.Object;
  779.     BEGIN (* SaveReg+ *)
  780.       RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame );
  781.  
  782.     END Label1A;
  783.  
  784.   PROCEDURE Label2* {"MuiSimple.Label2A"} ( label {8} : ARRAY OF CHAR):m.Object;
  785.   PROCEDURE Label2A * ( label{8} : e.STRPTR ):m.Object;
  786.     BEGIN (* SaveReg+ *)
  787.       RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame );
  788.     END Label2A;
  789.  
  790.   PROCEDURE KeyLabel*{"MuiSimple.KeyLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  791.   PROCEDURE KeyLabelA * ( label{8} : e.STRPTR; hichar{3} : LONGINT  ):m.Object;
  792.     BEGIN (* SaveReg+ *)
  793.       RETURN m.MakeObject( m.oLabel, label, 0+hichar );
  794.     END KeyLabelA;
  795.  
  796.   PROCEDURE KeyLabel1*{"MuiSimple.KeyLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  797.   PROCEDURE KeyLabel1A * ( label{8} : e.STRPTR; hichar{3} : LONGINT ):m.Object;
  798.     BEGIN (* SaveReg+ *)
  799.       RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame+hichar );
  800.     END KeyLabel1A;
  801.  
  802.   PROCEDURE KeyLabel2*{"MuiSimple.KeyLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  803.   PROCEDURE KeyLabel2A * ( label{8} : e.STRPTR; hichar{3} : LONGINT ):m.Object;
  804.     BEGIN (* SaveReg+ *)
  805.       RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
  806.     END KeyLabel2A;
  807.  
  808.   PROCEDURE KeyLLabel*{"MuiSimple.KeyLLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR):m.Object;
  809.   PROCEDURE KeyLLabelA * ( label{8} : e.STRPTR; hichar{3} : LONGINT ):m.Object;
  810.     BEGIN (* SaveReg+ *)
  811.       RETURN m.MakeObject( m.oLabel, label, 0+hichar );
  812.     END KeyLLabelA;
  813.  
  814.   PROCEDURE KeyLLabel1*{"MuiSimple.KeyLLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  815.   PROCEDURE KeyLLabel1A * ( label{8} : e.STRPTR; hichar{3} : LONGINT ):m.Object;
  816.     BEGIN (* SaveReg+ *)
  817.       RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame+m.oLabelLeftAligned+hichar );
  818.     END KeyLLabel1A;
  819.  
  820.   PROCEDURE KeyLLabel2*{"MuiSimple.KeyLLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  821.   PROCEDURE KeyLLabel2A * ( label{8} : e.STRPTR; hichar{3} : LONGINT ):m.Object;
  822.     BEGIN (* SaveReg+ *)
  823.       RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
  824.     END KeyLLabel2A;
  825.  
  826. (***************************************************************************
  827. **
  828. ** Controlling Objects
  829. ** -------------------
  830. **
  831. ** Set() and Get() are two short stubs for BOOPSI GetAttr() and SetAttrs()
  832. ** calls:
  833. **
  834. **
  835. **    VAR x : e.STRPTR;
  836. **
  837. **    Set(obj,MUIA_String_Contents, y.ADR("foobar") );
  838. **    Get(obj,MUIA_String_Contents, x);
  839. **
  840. **    Dos.PrintF( "gadget contains '%s'\n" , x );
  841. **
  842. ** NNset() sets an attribute without triggering a possible notification.
  843. **
  844. **
  845. ***************************************************************************)
  846.  
  847.   PROCEDURE Set*( obj : m.Object; attr, value : e.APTR );
  848.     BEGIN (* SaveReg+ *)
  849.       IF I.SetAttrs( obj, attr, value, u.end ) = 0 THEN END
  850.     END Set;
  851.  
  852.   PROCEDURE Get*( obj : m.Object; attr : LONGINT ; VAR store : ARRAY OF e.BYTE );
  853.     BEGIN (* SaveReg+ *)
  854.       IF I.GetAttr( attr, obj, store) = 0 THEN END
  855.     END Get;
  856.  
  857.   PROCEDURE NNSet( obj : m.Object; attr, value : e.APTR );
  858.     BEGIN (* SaveReg+ *)
  859.       IF I.SetAttrs( obj, m.aNoNotify, e.LTRUE, attr, value, u.end ) = 0 THEN END
  860.     END NNSet;
  861.  
  862.   PROCEDURE SetMutex * ( obj : m.Object; n : LONGINT );
  863.     BEGIN (* SaveReg+ *)
  864.       Set( obj, m.aRadioActive, n );
  865.     END SetMutex;
  866.  
  867.   PROCEDURE SetCycle * ( obj : m.Object; n : LONGINT );
  868.     BEGIN (* SaveReg+ *)
  869.       Set( obj, m.aCycleActive, n );
  870.     END SetCycle;
  871.  
  872.   PROCEDURE SetString * ( obj : m.Object; s : ARRAY OF CHAR );
  873.     BEGIN (* SaveReg+ *)
  874.       Set( obj, m.aStringContents, y.ADR( s ) );
  875.     END SetString;
  876.  
  877.   PROCEDURE SetCheckmark * ( obj : m.Object; b : BOOLEAN );
  878.     BEGIN (* SaveReg+ *)
  879.       Set( obj, m.aSelected, y.VAL(SHORTINT,b) );
  880.     END SetCheckmark;
  881.  
  882.   PROCEDURE SetSlider * ( obj : m.Object; l : LONGINT );
  883.     BEGIN (* SaveReg+ *)
  884.       Set( obj, m.aSliderLevel, l );
  885.     END SetSlider;
  886.  
  887.   PROCEDURE MAKEID*( c1, c2, c3, c4 : CHAR):LONGINT;
  888.     BEGIN (* SaveReg+ *)
  889.       RETURN( y.LSH( ORD(c1), 24 )+
  890.               y.LSH( ORD(c2), 16 )+
  891.               y.LSH( ORD(c3),  8 )+
  892.               ORD(c4) )
  893.     END MAKEID;
  894.  
  895. BEGIN
  896.   IF m.base.version < 8 THEN HALT( 100 ) END;
  897. END MuiSimple.
  898.  
  899.  
  900.